Persistent storage of network management data using object references

ABSTRACT

The invention relates to a method for managing a network comprising a plurality of network components, and to a corresponding network management system. According to the invention, information about the network is persistently stored by filing object references in a database. Object references are used for the unambiguous identification of an object, and an object is a program representation of a network component, containing an executable program routine which, when called, emits data containing the information to be stored, as a return value. The program routine can be localized by-means of the respective filed object reference. The persistent storage of network management data by means of dynamic object references enables a network management program to access novel types or categories of objects, during its run-time, without necessitating an upgrade or a service interruption. The objects are preferably JAVA objects or EJB (Enterprise Java Beans) objects. Preferably, the implementation is carried out in CORBA. The database containing the object references is preferably a relational database.

CROSS REFERENCE TO RELATED APPLICATIONS

This application is the US National Stage of International ApplicationNo. PCT/DE02/04618 filed Dec. 17, 2002 and claims the benefit thereof.The International Application claims the benefit of German applicationNo. 10163533.8 filed Dec. 21, 2001, both of the applications areincorporated by reference herein in their entirety.

FIELD OF INVENTION

This invention relates to networks comprising a plurality of networkcomponents, and is particularly concerned with the network management ofsuch a network.

BACKGROUND OF INVENTION

Networks such as computer networks are no longer merely supportingelements in a company, but are increasingly occupying a key position.The number of networked computers has always been rising fast in thepast, and has sometimes increased rapidly, and the complexity andfunctionality of the components is also expanding in accordance withperformance increases in the basic hardware.

Networks are often and increasingly structured heterogeneously. Forexample, modern, complex multi-service communication networks consist ofmany different network components, between which different relationshipsexist. Network components might be—for example—network elements such asrouters and switches, but might also be communication profiles forprotocols such as IP (Internet Protocol) and ATM (Asynchronous TransferMode), and physical and logical communication connections.

An example of a heterogeneous network is shown in FIG. 1 a, in whichnetwork components 120, 130; 140 of different types A, B, C areconnected together into a network. Network management systems 110 areused to ensure the operability of such a network.

The tasks of a network management system include—for example—maintainingservices, availability, and response times, protecting the quality ofservice by monitoring the components, and carrying out preventive faultand bottleneck correction. Management systems are also required torespond automatically or semi-automatically to operating faults, wherebythe configuration of the network is adjusted in real time in the eventof a fault. Management systems might also be expected—for example—toactivate redundant components in the event of a fault. Moreover,management systems must respond dynamically to changes in the networkand network environment, for example with regard to applications,subscribers, components, services, and charges. It must, however, alsobe possible—for example—to make dynamic adjustments to transmissionbandwidths.

Testing equipment is therefore also used as a network management tool,which can be used for testing the laid cables. Furthermore, networkmonitors are also used for monitoring and analyzing the data traffic onthe network. More comprehensive network management facilities areprovided by network management systems, which are based on definednetwork management standards such as SNMP (Simple Network ManagementProtocol).

Network management systems thus offer facilities for monitoring,administering and configuring networks from a central location, and thusalso combine the functions of a network monitor and a network analysistool. In terms of content, network management tasks can be divided intoconfiguration management, fault management and performance management.Configuration management is used for displaying and manipulatingdifferent network components such as hub systems, bridges, and routers.Fault management is used for tracing, analysis and correction of faults,particularly in a heterogeneous environment. Thus, for example, protocolpackets might be analyzed and the resulting data interpreted.Performance management supplies information about the efficiency ofcomponents and connections by continuous analysis of the network.

In order to fulfill these requirements, programs for management ofnetworks must know the general topology and the statuses of the network.For example, network management might involve the task of analyzing andconfiguring an end-to-end connection. Such a connection is shown in FIG.1 b, where the physical units of such a network are indicated betweenend points 160. As can be seen from the diagram, different networkcomponents of various types A, B, C are divided into differentsubnetworks 170, 180, 190, which are also known as domains. Thus in thisexample a network connection between the end points 160 takes place viadifferent domains containing different types of network components,which are interconnected by different types of physical and logicallinks and may also adhere to different protocols. If a networkmanagement system is to manage such an end-to-end connection, therefore,it must be able to retrieve all information about the network resources.

Since most networks are in place for longer than the average lifetime ofa management program, the data that contains this information aboutnetwork resources must be persistently stored outside the programs sothat it can be read in again at a later date. Persistent storage in thiscontext means the non-volatile filing of information in a memory thatrecords the swapped-out data inside itself for a fairly long time.Persistent storage may essentially be carried out on the computer 110 onwhich the network management program is running. The data may, however,also be stored on a different network computer 120, 130, 140, in whichcase the network management program on the computer 110 must haveresources available for accessing this persistently stored data.

Problems with conventional network management systems often arise as aresult of the rapid and dynamic further development in networktechnologies, and the constant expansion in networks that results fromthis. These expansions may be either quantitative or qualitative, i.e.they may result not only from the addition of further network componentsand subscribers, but also from the addition of novel types of networkcomponent and/or from the modification from existing types to new types.Network expansion is illustrated in FIG. 1 a, in which an existingnetwork is expanded by a network component 150 of a novel type N. Thisproduces the following problems.

since the network management station 110 can only monitor, administer,analyze and configure the network if it has access to all necessaryinformation about the components contained in the network, the systemmust be able to retrieve the relevant information from the components orfrom elsewhere. Thus, if a new component of a previously unknown type Nis added, the network management system cannot retrieve informationabout this component since the network management program does not yethave any means of querying the information relating to the novel type N.The network management program must therefore be expanded by theaddition of a corresponding module that has been set up forcommunication with network components of type N.

A further problem results from the fact that each network componentsupplies or may supply data in a different data format. If a novelcomponent is added to the network, the network management program musttherefore file this data in a separate memory or supplement the existingmemory by adding data fields in the new format. This means that nomodifications in the persistent storage are required, which are costlyand may even necessitate a reimplementation.

The above mentioned problems occur not only when a novel component isadded, but also when a novel protocol is activated or when existingcomponents or protocols are modified.

Thus, until now, the qualitative expansion of network technologies hasusually necessitated considerable cost as the result of upgrading theexisting network management solutions or from the costly synchronizationof the entire management system and its persistent data. Qualitativeexpansion of the network normally requires the replacement of programversions, whereby such programs often have to be replaced even thoughthey are not being expanded functionally, since they would no longerinteroperate with the expanded objects without adjustment of the code.The program replacement thus necessary in the prior art thereforeresults in undesirable and cost-intensive interruptions to operation.

SUMMARY OF INVENTION

The object of the invention is therefore to propose a method formanaging a network, and a network management system, that permitsqualitative modifications to be registered, evaluated and implemented inthe network without operation being interrupted.

This object is achieved by the invention described in the claims.

According to the invention, object references are used for persistentstorage of network management data. These object references are normallyused for defining the network management data generically. Since themanagement system stores references, it can also store references tosuch objects that were unknown at the time when the network managementprogram was produced. In this way, any number of objects of differentobject types (classes), even those that are referenced to one another,can be swapped out entirely generically to a persistent memory and readback in from there, without any modification to the existing programcode being required. Modifications to the data model can consequently becarried out completely transparently for existing programs, so that itis not necessary for the operation of active programs to be interrupted.

Preferred embodiments of the invention are specified in the subclaims.

The implementation of the invention by means of object-orientedprogramming permits the storage of references in an abstract,standardized data model. This is beneficial not only in order to obtainmaximum operating security, but also because it permits existingprogramming mechanisms to be used easily.

BRIEF DESCRIPTION OF THE DRAWINGS

To permit a more detailed description of exemplary embodiments of theinvention, reference is made below to the diagrams in which:

FIG. 1 a illustrates a heterogeneous network with a network managementstation and a network component of a novel type;

FIG. 1 b illustrates the physical components of an end-to-end connectionwith several domains;

FIG. 2 shows the elements of a network management system in a preferredembodiment of the invention;

FIG. 3 is a flow-chart of the process for reconstructing an object froma reference according to a preferred embodiment of the invention, and

FIG. 4 is a flow-chart of a process for defining the description of anetwork.

DETAILED DESCRIPTION OF INVENTION

The invention will now be explained in greater detail with reference tothe diagrams.

FIG. 2 shows the basic components of a network management station 110according to a preferred embodiment of the present invention. A centralcontrol unit 210 is connected to a user interface 220. The userinterface permits the operator to control the network management data.The control unit 210 is also connected to a network unit 230, via whichthe link to the network is effected. A reference database 240 is alsoprovided, which persistently stores the references. The referencedatabase is ideally a relational database.

Although the exemplary embodiment in FIG. 2 shows the reference database240 as being connected to the control unit 210, in another preferredembodiment of the invention the reference database 240 may be stored ona network computer. Access to the persistently stored references is theneffected by means of the control unit 210, via the network connection230.

The references filed in the reference database 240 refer to objects. Anobject is the program representation of a physical device in a network,for example an IP router or a telephone exchange. An object may alsorepresent a defined component or a module from such a physical device,such as—for example—a network component or a connection socket.Moreover, an object may also represent a physical or logical connectionline for the transmission of messages (e.g. a cable). An object may alsorepresent abstract logical data such as domains and end points, as wellas connections of resources or communication paths.

Objects are preferably implemented by an object-oriented programminglanguage such as Java. In this case objects can be formed by one or moreJava classes or by EJB (EnterpriseJavaBeans), or by a CORBA object andcorresponding stub utility classes for communication. Another form ofobject implementation can be achieved by appropriately selecting thedatabase scheme of the reference database 240 for persistent storage.

A reference is used for the unambiguous identification of an object,which is used by another object for a specific purpose and/or which isrelated to it in a specific way. Such a relationship may, for example,consist in that one object is contained within another object. Areference may refer to objects of different classes (object types), andcontains all information for accessing the persistently stored data.This is achieved in that a reference contains the class name of thereferenced object and a reference to the persistent storage location ofobjects of the referenced class, thus—for example—to the database tableused in a relational database. A reference thus contains the key toaccessing the persistently stored attributes of the referenced object.

Dynamic object references, which can be applied in systems withdistributed objects, e.g. CORBA and EJB, are preferably used. It isnecessary here to distinguish between the client (the user of a service)and the server (the supplier of the service). A single program maysimultaneously act as client for one service and as the server foranother service. A program may also be a method of an object.

The content of the references is analyzed interpretatively by theprogram at runtime. According to a preferred embodiment of theinvention, references are generically constructed, whereby the network

-   -   management program recognizes the generic construction. The        reference contains no further semantic information about the        content, and therefore—for example—no information about the data        structure of the class of the object referenced. Thus the        network management project is also able to handle such        references that refer to the objects of novel classes that were        not yet known at the time when the program was produced.

In a preferred embodiment of the invention, references are always of thesame data type at program runtime. References are preferablypersistently stored in a database field as a string.

A preferred construction of a reference consists of the Java class nameand an unambiguous identification code, which clearly differentiatesbetween the various entities of the class, i.e. the objects. If—forexample—the classes Network and GateNE are present, then the referencesmight be Network_(—)1, Network_(—)2, GateNE_IPRouter_(—)1,GateNE_IPRouter_(—)2, etc.

The reference thus contains all information necessary for reconstructingthe object. An object is then only ever reconstructed from a referenceif one or more methods of an object are to be called. Methods areexecutable program routines that are part of the corresponding object.The code that calls the methods on the referenced object, i.e. theprogram running on the client, uses the new class in the server, whichis still unknown at programming time. It interprets the referenceattribute of the type string by applying a naming convention at programruntime and uses the appropriate programming language resource to loadthe new classes and then to address methods of the objects on theserver.

FIG. 3 is a flow-chart that illustrates this process in greater detail.Firstly, the control unit 210 reads out a reference from the referencedatabase 240 in stage 310. A reference may alternatively also resultfrom a method of a different object being called. In this case the classof the reference object is defined at runtime in stage 320. In the aboveexample, this is done by evaluation of the reference string thatcontains the class name.

The class is now loaded. (stage 330), likewise at runtime. In the Javaprogramming language, for example, this is facilitated by the so-calledReflection API and the integrated ClassLoader. In stage 340, then, thereferenced object is generated at runtime as an entity of the definedand loaded class. Finally, in stage 350 one or more methods of thegenerated entities are called at runtime.

An example is now explained in greater detail with reference to FIG. 4,to show how the aforementioned method for managing a network can beimplemented for a network. The flow-chart shown in FIG. 4 shows aprocess by which the client program is to define a description of thenetwork. In the example, the network is described only by the followingclasses for the purpose of simplification:

-   -   Class IPRouter:        -   Method getNextHop( )        -   Method getDescription( )    -   Class LanSwitch:        -   Method getNextHop( )        -   Method getDescription( )

The two classes IPRouter and LanSwitch implement the methods getNextHop() and getDescription( ) respectively getNexHop( ) delivers one or morereferences to the objects that are logically connected to the currentobject. getDescription( ) delivers a description of the current object.

In the process shown in FIG. 4, the program starts in stage 410 with theselection of a starting object, for example on the basis of a knownobject in the network, for which the reference can be entered by theoperator. The operator may enter the reference, for example, by directlyinputting the reference string if it is known. Alternatively, theoperator may select an object on a user interface, e.g. with a mouse. Inthis case the reference string must then be read out from the referencedatabase 240.

In stage 420, in the alternative procedure mentioned, the referencestring for the selected starting object is read out from the referencedatabase 240. The name of the factory object (J2EE=Home Interface) isthen defined from the reference string by application of the namingconvention. Thus, with reference to the above examples, the nameIPRouterHome of the factory object is defined as the string fromIPRouter_(—)2. In a different example, the factory name LanSwitchHome isobtained from LanSwitch_(—)1111. If the class of the defined factoryobject is unknown, the program is terminated and/or a new reference isqueried.

After the name of the factory object has been defined in this way instage 430, the factory object is produced using the Reflection API.

-   -   ObjectfObject=Class.forName (factoryName)

Then, in stage 450, a CORBA reference to the object is produced bycalling the method findByPrimaryKey( ).

-   -   Object rObjectRemote=fObject.findByPrimaryKey(refString)

If the CORBA object being searched for does not yet exist in the server,it is loaded into the server from the database.

Now, in stage 460, a request is transmitted from the client to theservice. For this purpose only a stub is addressed in the client (viarObjectRemote). In the server the call is diverted to the concreteimplementation of the class. The server knows the persistent storagelocation of the data describing the network and has the necessaryresources to produce the server object from the contents of thedatabase.

The server object produced may now be used, in stage 470, to retrievethe required methods.

-   -   rObjectRemote.invoke(“getDescription”, etc.)    -   rObjectRemote.invoke(“getNextHop”, etc.)

With the result of getNextHop( ), which normally delivers a number ofreferences, the client can find all objects that describe the network byrepeated application of stages 420 to 470. For this purpose, the processprovides a branch 480 which arranges for the aforementioned stages to berepeated if no other references are available.

The preferred exemplary embodiment described above thus provides apossibility for managing a network by persistent storage of dynamicobject references. Since, in this instance, the methods getDescription() and getNextHop( ) can be localized only by means of the respectivefiled object references (and the respective method names), persistentstorage of class-related data is not necessary. The application ofdynamic object references thus enables the implementation of a server tobe replaced or removed for a service, or further servers to be added,without the need for any modification, reprogramming, retranslation,upgrading, or restarting of the active client programs.

Instead, only measures outside of the network management program arerequired if—for example—a new class of objects that require a completelynew type of NextHop( ) implementation, is imported into the systemduring the program runtime. If, for example, objects in a classATMSwitch, which does not yet exist in the network, are added to saidnetwork, the implementation of the class ATMSwitch and its stub classesmust be imported at the server computer and loaded into the server, forexample by means of deployment in Java EJB. Entities of the classATMSwitch must then be produced in the server and references to theproduced objects must be added in several of the existing objects.

Only stub classes of ATMSwitch need to be imported into the class loaderpath on the client computer. However, no modification of the networkmanagement program or data format of the persistent storage isnecessary. The network management program may therefore use the newobjects without operation being interrupted.

1-18. (canceled)
 19. A Method for managing a network comprising aplurality of network components, the method comprising: retrieving data,describing the network; providing in the data, describing the network,information about network components in the network; and storing theretrieved information in a persistent data storage; wherein theretrieved information is stored by filing object references in adatabase, wherein an object reference is an unambiguous identificationof an object, wherein an object is a program representation of a networkcomponent, comprising an executable program routine which, when called,emits data containing the information to be stored, as a return value,and wherein the program routine is accessible by the respective filedobject reference.
 20. The Method according to claim 19, whereinreferenced objects are classified into classes according to their objecttype, and wherein the object references comprise the name of the classof the object referenced respectively.
 21. The Method according to claim19, wherein the object references also comprise an identification codewhich unambiguously identifies the object of the relevant class as anentity of the class.
 22. The Method according to claim 19, wherein theobject references data type is string and they are based on aconstruction that permits the class name to be extracted from thereference string on the basis of its position.
 23. The Method accordingto claim 19, wherein the data, that is emitted as a return value by theprogram routine, comprises further object references.
 24. The Methodaccording to claim 19, wherein a network component is a physical devicein the network.
 25. The Method according to claim 19, wherein a networkcomponent is a component or a module of a physical device in thenetwork.
 26. The Method according to claim 19, wherein a networkcomponent is a physical and/or logical communication connection.
 27. TheMethod according to claim 19, wherein a network component is a domain,an end point, or another logical network unit.
 28. The Method accordingto claim 19, wherein a network component is a communication profile forprotocols.
 29. The Method according to claim 19, wherein the programrepresentation is a Java representation.
 30. The Method according toclaim 19, wherein the program representation is an EJB representation.31. The Method according to claim 19, wherein the program routine can belocalized by the respective filed object reference in a CORBAimplementation.
 32. The Method according to claim 19, wherein theobjects can be implemented by the database scheme of a relationaldatabase.
 33. The Method according to claim 19, wherein the retrievingdata step comprises: reading out an object reference; defining the classof the referenced object; loading the defined class; producing an entityof the loaded class; and calling the program routine for the producedentity.
 34. The Method according to claim 19, further comprisingadapting the method to a network component of a new type, wherein thiscomprises: implementing a class that represents the new type, in aserver; producing of objects as entities of the new class in the server;adding references to the produced objects in at least one of theexisting objects; and importing stub classes of the new classes into theclass loader path of a client.
 35. The Method according to claim 19,wherein the retrieving data step comprises retrieving data describingthe network, from at least one network component.
 36. The Methodaccording to claim 19, wherein the retrieving data step comprisesretrieving data describing the network, by at least one networkcomponent.
 37. A Network management system for managing a networkcomprising a plurality of network components, comprising: a device forquerying data, describing the network, from at least one networkcomponent, wherein the data describing the network comprises informationabout network components the network comprises; and a memory for thepersistent storage of the retrieved information by filing of objectreferences in a database, wherein an object reference is an unambiguousidentification of an object, wherein an object is a programrepresentation of a network component, containing an executable programroutine which, when called, emits data comprising the information to bestored, as a return value, wherein the program routine can be localizedsolely by the respective filed object reference.
 38. A Method formanaging a network comprising a plurality of network components, themethod comprising: retrieving data, describing the network; providing inthe data, describing the network, information about network componentsin the network; and storing the retrieved information in a persistentdata storage, wherein storing the retrieved information comprises filingobject references in a database, wherein an object reference is used forthe unambiguous identification of an object, wherein an object is aprogram representation of a network component, comprising an executableprogram routine which, when called, emits data containing theinformation to be stored, as a return value, and wherein a programroutine can be localized by the respective filed object reference.